Aminet 38/Aminet 38 (2000)(Schatztruhe)[!][Aug 2000].iso/Aminet/util/moni/Scout-src.lha/src/objects/scout_extras.c

C/C++ Source or Header | 2000-03-09 | 85.0 KB | 2,474 lines

/**
 * Scout - The Amiga System Monitor
 *
 *------------------------------------------------------------------
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * You must not use this source code to gain profit of any kind!
 *
 *------------------------------------------------------------------
 *
 * @author Andreas Gelhausen
 * @author Richard Körber <[e-mail]>
 */



#define USE_SCOUT_LOGO_COLORS
#define USE_SCOUT_LOGO_BODY

#include "scout_extras.h"
#include "/scout_logo.h"

#define WINDOWTITLELEN  80

extern struct Library   *GfxBase;
extern struct ExecBase  *SysBase;
extern APTR AboutText;

static char SPACE40[] = "                                        ";

UBYTE  updatetimetext[] = "1.0\0\0\0\0\0";
ULONG  updatetimestate;

ULONG MakeListID (char a, char b, char c, char d) {

   if (opts.SingleWindows) {
      return ((ULONG) ('L')<<24 | (ULONG) ('I')<<16 | (ULONG) ('S')<<8 | (ULONG) ('T'));
   } else {
      return ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d));
   }
}

ULONG MakeDetailID (char a, char b, char c, char d) {

//   if (opts.SingleWindows) {
//      return ((ULONG) ('M')<<24 | (ULONG) ('O')<<16 | (ULONG) ('R')<<8 | (ULONG) ('E'));
//   } else {
      return ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d));
//   }
}

struct Node *HandleNodeDetails (APTR list, char *type) {
   struct ListEntry  *entryp;
   struct Node       *node = NULL;

   if (entryp = GetActiveEntry (list)) {
      node = MyFindName (type, entryp->le_address);
      if (!node)
         MyRequest ("Continue", "Sorry, can't find that %ls!", type);
   }
   return (node);
}

void MySetContents (APTR textfield, char *fmt, ...) {
   va_list arg;
   char buf[512];

   va_start(arg,fmt);
   vsprintf(buf, fmt, arg);
   va_end(arg);

   set (textfield, MUIA_Text_Contents, buf);
}

void MySetContentsHealed (APTR textfield, char *fmt, ...) {
   va_list arg;
   char buf[512];

   va_start(arg,fmt);
   vsprintf(buf, fmt, arg);
   va_end(arg);

   healstring (buf);
   set (textfield, MUIA_Text_Contents, buf);
}

void MyFreeStructs (struct Remember **rem, APTR listtext, APTR list) {
   if (*rem) {
      if (AP_Scout) {
         if (listtext)
            set (listtext,MUIA_Text_Contents,"");
         if (list)
            DoMethod (list,MUIM_List_Clear);
      }
      FreeRemember (rem, TRUE);
      *rem = NULL;
   }
}

void SetCountText (APTR counttext, int structcnt) {
   MySetContents (counttext, ESC "r%04d", structcnt);
}

void SetCloseRequest (APTR window, int id) {
   DoMethod (window,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,AP_Scout,2,MUIM_Application_ReturnID,id);
}

struct WinFree *SingleDetailWinFree = NULL;

char *MyGetWindowTitle (char *titleptr, char *type) {
   int i;

   if (type[0] == '\0') {
      strcpy (tmpstr, "SCOUT");
   } else {
      sprintf (tmpstr, "SCOUT: %ls", type);
   }
   Forbid();
   if (FindPort ("AMITCP")) {
      Permit();
      if (opts.Host) {
         strcat (tmpstr, "   [ ");
         strcat (tmpstr, opts.Host);
         strcat (tmpstr, " ]");
      } else {
         Permit();
         strcat (tmpstr, "   [ LOCALHOST ]");
      }
   }

   for (i = 7; i < strlen (tmpstr); i++) {
      tmpstr[i] = toupper (tmpstr[i]);
   }
   strcpy (titleptr, tmpstr);
   return (titleptr);
}

void HandleFlagsButtonPressed (APTR button, struct WinFree *ptr, char *title2, char *fieldname, ULONG flags, struct LongFlag *longflag, struct MaskedLongFlag *mlongflag, char fieldtype) {
   struct WinFlag *winflag;

   if (winflag = AllocRemember (&ptr->wf_RememberKey, sizeof (struct WinFlag), MEMF_ANY|MEMF_CLEAR)) {
      winflag->wf_title2 = title2;
      winflag->wf_fieldname = fieldname;
      winflag->wf_flags = flags;
      winflag->wf_longflag = longflag;
      winflag->wf_mlongflag = mlongflag;
      winflag->wf_fieldtype = fieldtype;
      DoMethod (button,MUIM_Notify,MUIA_Pressed,FALSE,AP_Scout,3,MUIM_WriteLong,(ULONG) winflag,(ULONG *) &WinFlag_ToDo);
   }
}

void HandleWindowOpen (struct WinFree *ptr, char *titlepart1, char *titlepart2) {
   UBYTE *fulltitle;
   UBYTE *titlepart2ptr;

   if (opts.SingleWindows && SingleDetailWinFree) {
      WinFree_ToDo = SingleDetailWinFree;
      RemoveWinFree ();
   }
   SingleDetailWinFree = ptr;
   titlepart2ptr = nonetest (titlepart2);

   fulltitle = AllocRemember (&ptr->wf_RememberKey, strlen(titlepart1) + strlen(titlepart2ptr) + 4, MEMF_ANY|MEMF_CLEAR);
   sprintf (fulltitle, "%s%s", titlepart1, titlepart2ptr);
   healstring (fulltitle);

   set (ptr->wf_Window,MUIA_Window_Title,fulltitle);
   DoMethod (AP_Scout,OM_ADDMEMBER,ptr->wf_Window);
   SetWindowOpen (ptr->wf_Window,NULL,NULL);
}

void HandleWindowClose (struct WinFree *ptr) {
   DoMethod (ptr->wf_Window,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,AP_Scout,3,MUIM_WriteLong,(ULONG) ptr,(ULONG *) &WinFree_ToDo);
   SetCloseRequest (ptr->wf_Window,ID_REMOVEWINFREE);
}

ULONG LastListID = NULL;

void SetWindowOpen (APTR window, APTR active, ULONG ListID) {
   if (opts.SingleWindows) {
      if (ListID) {
         if (LastListID && (LastListID != ListID)) {
            if (SingleDetailWinFree) {
               WinFree_ToDo = SingleDetailWinFree;
               RemoveWinFree ();
            }
          DoMethod (AP_Scout,MUIM_Application_ReturnID,LastListID);
         }
         LastListID = ListID;
      }
   }

   set (window,MUIA_Window_Open,TRUE);
}

void SetWindowClose (APTR window, BOOL IsList) {
   if (opts.SingleWindows && IsList) {
      if (SingleDetailWinFree) {
         WinFree_ToDo = SingleDetailWinFree;
         RemoveWinFree ();
      }
   }
   set (window,MUIA_Window_Open,FALSE);
}

void ApplicationSleep (void) {
   set (AP_Scout,MUIA_Application_Sleep,TRUE);
}

void AwakeApplication (void) {
   set (AP_Scout,MUIA_Application_Sleep,FALSE);
}

void RedrawActiveEntry (APTR list) {
   DoMethod (list, MUIM_List_Redraw, MUIV_List_Redraw_Active);
}

void RemoveActiveEntry (APTR list) {
   DoMethod (list, MUIM_List_Remove, MUIV_List_Redraw_Active);
}

void InsertBottomEntry (APTR list, APTR *entry) {
   DoMethod (list, MUIM_List_Insert, entry, 1, MUIV_List_Insert_Bottom);
}

void InsertSortedEntry (APTR list, APTR *entry) {
   DoMethod (list, MUIM_List_Insert, entry, 1, MUIV_List_Insert_Sorted);
}

struct ListEntry *GetActiveEntry (APTR list) {
   struct ListEntry *result = NULL;

   if (list)
      DoMethod (list,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&result);
   return (result);
}

void SetListActive (APTR list, int id) {
   DoMethod (list,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,AP_Scout,2,MUIM_Application_ReturnID,id);
}

void SetListviewDoubleClick (APTR list, int id) {
   if (! clientstate)
      DoMethod (list,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,AP_Scout,2,MUIM_Application_ReturnID,id);
}

APTR KeyButtonA (char *buttontext, int buttonid) {
   APTR result;
   result = MUI_MakeObject (MUIO_Button, buttontext);
   DoMethod (result,MUIM_Notify,MUIA_Pressed,FALSE,AP_Scout,2,MUIM_Application_ReturnID,buttonid);
   return (result);
}

APTR KeyButtonB (char *buttontext, char key, int buttonid) {
   APTR result;
   result = KeyButton (buttontext, key);
   DoMethod (result,MUIM_Notify,MUIA_Pressed,FALSE,AP_Scout,2,MUIM_Application_ReturnID,buttonid);
   return (result);
}

APTR KeyButtonF (char fieldtype, ULONG flags) {
   APTR result;
   char buttontext[16];

   if (fieldtype == 'l') {
      sprintf (buttontext, ESC "b$%08lx", (ULONG) flags);
   } else if (fieldtype == 'w') {
      sprintf (buttontext, ESC "b$%04lx", (UWORD) flags);
   } else {
      sprintf (buttontext, ESC "b%%%ls", ltob ((ULONG) flags, 8));
   }
   result = TextObject,\
                ButtonFrame,\
                      MUIA_Text_Contents, buttontext,\
                MUIA_Text_PreParse, "\33r",\
                MUIA_InputMode    , MUIV_InputMode_RelVerify,\
                MUIA_Background   , MUII_ButtonBack,\
                End;

   DoMethod (result,MUIM_Notify,MUIA_Pressed,FALSE,AP_Scout,2,MUIM_Application_ReturnID,ID_FLAGWINDOW);
   return (result);
}

__asm LONG flaglist_dspfunc(register __a2 char **array, register __a1 struct FlagEntry *flagentry, register __a0 struct Hook *hook) {
   if (flagentry) {
      *array++ = flagentry->fe_name;
      *array++ = flagentry->fe_text;
      *array   = NULL;
   }
   return(0);
}

struct Hook flaglist_dsphook = {
 {NULL, NULL},
 (ULONG (* )())flaglist_dspfunc,
 NULL, NULL
};

void GetFlagsMore (char *title2, char *fieldname, ULONG flags, struct LongFlag *longflag, struct MaskedLongFlag *mlongflag, char fieldtype) {
   unsigned char     flaglabel[40];
   struct   WinFree  *ptr;
   APTR  flagsmorelist;


   if (fieldtype == 'l') {
      sprintf ((char *) &flaglabel, "%ls = $%08lx", fieldname, flags);
   } else if (fieldtype == 'w') {
      sprintf ((char *) &flaglabel, "%ls = $%04lx", fieldname, flags);
   } else {
      sprintf ((char *) &flaglabel, "%ls = %%%ls", fieldname, ltob ((ULONG) flags, 8));
   }

   if (ptr = AllocWinFree()) {
      ptr->wf_Window = (APTR) WindowObject,

//      MUIA_Window_SizeGadget, FALSE,
      MUIA_Window_ID, MakeDetailID('F','L','A','G'),
      WindowContents, VGroup,
         Child, HGroup,
            Child, MyHSpace (0),
            Child, MyLabel2 (flaglabel),
            Child, MyHSpace (0),
         End,
         Child, flagsmorelist = ListviewObject,
            MUIA_Listview_DoubleClick, TRUE,
            MUIA_Listview_Input, FALSE,
            MUIA_Listview_List, ListObject,
            MUIA_List_Format, "COL=0 DELTA=8,COL=1",
//            MUIA_List_Title, TRUE,
            MUIA_List_DisplayHook, &flaglist_dsphook,
            ReadListFrame,
         End, End,
      End, End;

      if (ptr->wf_Window) {
         int i = 0;

         set(flagsmorelist,MUIA_List_Quiet,TRUE);
         if (longflag) {
            while (((struct LongFlag *) &longflag[i])->lf_name) {
               if (flags & ((struct LongFlag *) &longflag[i])->lf_value) {
                  DoMethod (flagsmorelist,MUIM_List_InsertSingle,((struct FlagEntry *) &((struct LongFlag *) &longflag[i])->lf_name),MUIV_List_Insert_Bottom);
               }
               i++;
            }
         }
         i = 0;
         if (mlongflag) {
            while (((struct MaskedLongFlag *) &mlongflag[i])->mlf_name) {
               if ((flags & ((struct MaskedLongFlag *) &mlongflag[i])->mlf_mask) == ((struct MaskedLongFlag *) &mlongflag[i])->mlf_value) {
                  DoMethod (flagsmorelist,MUIM_List_InsertSingle,((struct FlagEntry *) &((struct MaskedLongFlag *) &mlongflag[i])->mlf_name),MUIV_List_Insert_Bottom);
               }
               i++;
            }
         }
         set(flagsmorelist,MUIA_List_Quiet,FALSE);

         HandleWindowOpen (ptr, "FLAGS  ", title2);
         set (ptr->wf_Window,MUIA_Window_ActiveObject,flagsmorelist);
         HandleWindowClose (ptr);
      }
   }
}

APTR MyListviewObject (unsigned char *formatstring, APTR displayhook) {
   return (ListviewObject,
            MUIA_Listview_List, ListObject,
            MUIA_List_Format, formatstring,
            MUIA_List_Title, TRUE,
            MUIA_List_DisplayHook, displayhook,
            InputListFrame,
           End, End);
}

/*
APTR MyBelowSortedListview (APTR *text, APTR *count, APTR *cycle, const char *sorttext[], int sortstate) {
 return (HGroup,
            Child, VGroup,
               Child, *text = MyTextObject5(SPACE40),
                  Child, MyLabel ("sorted by:"),
               End,
               Child, VGroup, MUIA_HorizWeight, 0,
                  Child, HGroup,
                     Child, MyLabel (" Cnt:"),
                     Child, *count = MyTextObject4("0000"),
                  End,
                  Child, *cycle = CycleObject,
                     MUIA_Cycle_Entries, sorttext,
                     MUIA_Cycle_Active, sortstate,
                  End,
               End,
            End);
}
*/

APTR MyBelowSortedListview (APTR *text, APTR *count, APTR *cycle, const char *sorttext[], int sortstate) {
 return (HGroup,
            Child, *text = MyTextObject5(SPACE40),
            Child, HGroup, MUIA_HorizWeight, 0,
               Child, MyLabel (" Cnt:"),
               Child, *count = MyTextObject4("0000"),
               Child, MyLabel ("sorted by:"),
               Child, *cycle = CycleObject,
                  MUIA_Cycle_Entries, sorttext,
                  MUIA_Cycle_Active, sortstate,
               End,
            End,
         End);
}

APTR MyBelowListview (APTR *text, APTR *count) {
 return (HGroup,
         Child, *text = MyTextObject5(SPACE40),
         Child, HGroup, MUIA_HorizWeight, 0,
            Child, MyLabel (" Cnt:"),
            Child, *count = MyTextObject4("0000"),
         End,End);
}

APTR MyLabel (char *labeltext) {
   return (LabelA (labeltext));
}

APTR MyLabel2 (char *labeltext) {
   return (LabelB (labeltext));
}

APTR MyHSpace (int size) {
   return (HSpace (size));
}

APTR MyVSpace (int size) {
   return (VSpace (size));
}

APTR MyTextObject () {
   return ( TextObject, MyTextFrame, End );
}

APTR MyTextObject2 () {
   return ( TextObject, MyTextFrame, MUIA_Text_SetMax, TRUE, End );
}

APTR MyTextObject3 (char *text) {
   return ( TextObject, MyTextFrame, MUIA_Text_Contents, text, End );
}

APTR MyTextObject4 (char *text) {
   return ( TextObject, MyTextFrame, MUIA_Text_SetMax, TRUE, MUIA_Text_Contents, text, End );
}

APTR MyTextObject5 (char *text) {
   return ( TextObject, MyTextFrame, MUIA_Text_SetMin, TRUE, MUIA_Text_Contents, text, End );
}

const char *AboutText1  = MUIX_C "\n"\
                          PROGNAME " V" PROGVERSION "." PROGREVISION "\n"\
                          "Release " RELEASEVERSION "." RELEASEREVISION " (" RELEASEDATE ")\n"\
                          COPYRIGHT "\nAll Rights Reserved\n\n"\
                          "This program is \33bFreeWare\33n.\n"\
                          "MUI is © by Stefan Stuntz.\n\n"\
                          "\33lEMail: " EMAIL "\nURL: " URL "\n\n"\
                          "ARexx port name: ";

static char *VectorPages[] = { "ResetVecs","AutoVecInts","IntVecs",NULL };
static char *AllocationsPages[] = { "CIA","Ports",NULL };
char  LibDevResFormatText[] = "COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8 P=\33r,COL=5";

__asm LONG list_cmpaddressfunc (register __a1 struct ListEntry *le1, register __a2 struct ListEntry *le2) {
   return (strcmpi (le1->le_address, le2->le_address));
}

struct Hook list_cmpaddresshook = {
 {NULL, NULL},
 (ULONG (* )())list_cmpaddressfunc,
 NULL, NULL
};

__asm LONG list_cmpnormalfunc (register __a1 struct ListEntry *le1, register __a2 struct ListEntry *le2) {
   return (1);
}

struct Hook list_cmpnormalhook = {
 {NULL, NULL},
 (ULONG (* )())list_cmpnormalfunc,
 NULL, NULL
};

__asm LONG list_cmpnamefunc (register __a1 struct ListEntry *le1, register __a2 struct ListEntry *le2) {
   LONG result;
   if (result = strcmpi (le1->le_name, le2->le_name))
      return (result);
   return (1);
}

struct Hook list_cmpnamehook = {
 {NULL, NULL},
 (ULONG (* )())list_cmpnamefunc,
 NULL, NULL
};

__asm LONG locklist_cmppathfunc (register __a1 struct LockEntry *le1, register __a2 struct LockEntry *le2) {
   return (strcmpi (le1->lock_path, le2->lock_path));
}

struct Hook locklist_cmppathhook = {
 {NULL, NULL},
 (ULONG (* )())locklist_cmppathfunc,
 NULL, NULL
};

__asm LONG tasklist_cmpprifunc (register __a1 struct TaskEntry *te1, register __a2 struct TaskEntry *te2) {
   long  eins = NULL, zwei = NULL;

   IsDec (te1->ts_pri, &eins);
   IsDec (te2->ts_pri, &zwei);
   if (eins < zwei)
      return (1);
   return (-1);
}

struct Hook tasklist_cmpprihook = {
 {NULL, NULL},
 (ULONG (* )())tasklist_cmpprifunc,
 NULL, NULL
};

__asm LONG tasklist_cmpaddressfunc (register __a1 struct ListEntry *le1, register __a2 struct ListEntry *le2) {
   if (le1->le_adr < le2->le_adr)
      return (-1);
   return (1);
}

struct Hook tasklist_cmpaddresshook = {
 {NULL, NULL},
 (ULONG (* )())tasklist_cmpaddressfunc,
 NULL, NULL
};

__asm LONG cxlist_cmpprifunc (register __a1 struct CxEntry *ce1, register __a2 struct CxEntry *ce2) {
   long  eins = NULL, zwei = NULL;

   IsDec (ce1->cxe_pri, &eins);
   IsDec (ce2->cxe_pri, &zwei);
   if (eins < zwei)
      return (1);
   return (-1);
}

struct Hook cxlist_cmpprihook = {
 {NULL, NULL},
 (ULONG (* )())cxlist_cmpprifunc,
 NULL, NULL
};

__asm LONG cxlist_cmpaddressfunc (register __a1 struct CxEntry *ce1, register __a2 struct CxEntry *ce2) {
   if (ce1->cxe_adr < ce2->cxe_adr)
      return (-1);
   return (1);
}

struct Hook cxlist_cmpaddresshook = {
 {NULL, NULL},
 (ULONG (* )())cxlist_cmpaddressfunc,
 NULL, NULL
};

__asm LONG cxlist_cmpnamefunc (register __a1 struct CxEntry *ce1, register __a2 struct CxEntry *ce2) {
   LONG result;
   if (result = strcmpi (ce1->cxe_name, ce2->cxe_name))
      return (result);
   return (1);
}

struct Hook cxlist_cmpnamehook = {
 {NULL, NULL},
 (ULONG (* )())cxlist_cmpnamefunc,
 NULL, NULL
};

__asm LONG classlist_cmpaddressfunc (register __a1 struct ClassEntry *ce1, register __a2 struct ClassEntry *ce2) {
   if (ce1->cse_adr < ce2->cse_adr)
      return (-1);
   return (1);
}

struct Hook classlist_cmpaddresshook = {
 {NULL, NULL},
 (ULONG (* )())classlist_cmpaddressfunc,
 NULL, NULL
};

__asm LONG classlist_cmpnamefunc (register __a1 struct ClassEntry *ce1, register __a2 struct ClassEntry *ce2) {
   LONG result;
   if (result = strcmpi (ce1->cse_classname, ce2->cse_classname))
      return (result);
   return (1);
}

struct Hook classlist_cmpnamehook = {
 {NULL, NULL},
 (ULONG (* )())classlist_cmpnamefunc,
 NULL, NULL
};

__asm LONG classlist_cmpsuperfunc (register __a1 struct ClassEntry *ce1, register __a2 struct ClassEntry *ce2) {
   LONG result;
   if (result = strcmpi (ce1->cse_super, ce2->cse_super))
      return (result);
   return (1);
}

struct Hook classlist_cmpsuperhook = {
 {NULL, NULL},
 (ULONG (* )())classlist_cmpsuperfunc,
 NULL, NULL
};

__asm LONG smodelist_cmpidfunc (register __a1 struct SModeEntry *se1, register __a2 struct SModeEntry *se2) {
   if (se1->sme_smodeid < se2->sme_smodeid)
      return (-1);
   return (1);
}

struct Hook smodelist_cmpidhook = {
 {NULL, NULL},
 (ULONG (* )())smodelist_cmpidfunc,
 NULL, NULL
};

__asm LONG smodelist_cmpresfunc (register __a1 struct SModeEntry *se1, register __a2 struct SModeEntry *se2) {
   long  eins = NULL, zwei = NULL;

   IsDec (se1->sme_width, &eins);
   IsDec (se2->sme_width, &zwei);
   if(eins!=zwei) return(eins>zwei ? 1 : -1);
   IsDec (se1->sme_height, &eins);
   IsDec (se2->sme_height, &zwei);
   if(eins!=zwei) return(eins>zwei ? 1 : -1);
   IsDec (se1->sme_depth, &eins);
   IsDec (se2->sme_depth, &zwei);
   return(eins>zwei ? 1 : -1);
}

struct Hook smodelist_cmpreshook = {
 {NULL, NULL},
 (ULONG (* )())smodelist_cmpresfunc,
 NULL, NULL
};

__asm LONG smodelist_cmpnamefunc (register __a1 struct SModeEntry *se1, register __a2 struct SModeEntry *se2) {
   STRPTR s1 = se1->sme_name, s2 = se2->sme_name;
   LONG result;

//*   if(*s1=='\033') s1+=2;
//*   if(*s2=='\033') s2+=2;

   if (result = strcmpi (s1,s2))
      return (result);
   return (1);
}

struct Hook smodelist_cmpnamehook = {
 {NULL, NULL},
 (ULONG (* )())smodelist_cmpnamefunc,
 NULL, NULL
};


char main_title[WINDOWTITLELEN];

APTR GetApplication (void) {
   AP_Scout = ApplicationObject,
      MUIA_Application_Title      , PROGNAME,
      MUIA_Application_Version    , "$VER: " VERSIONSTRING,
      MUIA_Application_Copyright  , COPYRIGHT,
      MUIA_Application_Author     , AUTHOR,
      MUIA_Application_Description, DESCRIPTION,
      MUIA_Application_Base       , PROGNAME,
      MUIA_Application_Commands   , arexx_list,
      MUIA_Application_Menu       , menu_list,
//      MUIA_Application_SingleTask , TRUE,
//      MUIA_Application_DiskObject , &scout_sleep_dobj,
      MUIA_Application_HelpFile   , "scout.guide",
   End;

   if (AP_Scout) {
      WI_Main = WindowObject,
      MUIA_Window_Title, MyGetWindowTitle (main_title, ""),
         MUIA_HelpNode, "Main",
         MUIA_Window_ID, MakeID('M','A','I','N'),
         WindowContents, HGroup,
            MUIA_Group_SameHeight, TRUE,
            Child, VGroup,                  /* This is the SCOUT logo */
               MUIA_Weight    , 0,
               MUIA_Frame     , MUIV_Frame_Text,
               MUIA_Background, MUII_SHADOW,
               Child, VSpace(0),
               Child, BodychunkObject,
                  MUIA_FixWidth             , SCOUT_LOGO_WIDTH ,
                  MUIA_FixHeight            , SCOUT_LOGO_HEIGHT,
                  MUIA_Bitmap_Width         , SCOUT_LOGO_WIDTH ,
                  MUIA_Bitmap_Height        , SCOUT_LOGO_HEIGHT,
                  MUIA_Bodychunk_Depth      , SCOUT_LOGO_DEPTH ,
                  MUIA_Bodychunk_Body       , scout_logo_body  ,
                  MUIA_Bodychunk_Compression, SCOUT_LOGO_COMPRESSION,
                  MUIA_Bodychunk_Masking    , SCOUT_LOGO_MASKING,
                  MUIA_Bitmap_SourceColors  , scout_logo_colors,
                  MUIA_Bitmap_Transparent   , 0,
               End,
               Child, VSpace(0),
            End,
            Child, ColGroup(5),             /* And this are the buttons */
               Child, BT_Libraries    = KeyButtonB (LibrariesText    ,'l',ID_LIBRARIES),
               Child, BT_Devices      = KeyButtonB (DevicesText      ,'d',ID_DEVICES),
               Child, BT_Resources    = KeyButtonB (ResourcesText    ,'u',ID_RESOURCES),
               Child, BT_Semaphores   = KeyButtonB (SemaphoresText   ,'s',ID_SEMAPHORES),
               Child, BT_Allocations  = KeyButtonB (AllocationsText  ,'a',ID_ALLOCATIONS),

               Child, BT_Tasks        = KeyButtonB (TasksText        ,'t',ID_TASKS),
               Child, BT_Ports        = KeyButtonB (PortsText        ,'p',ID_PORTS),
               Child, BT_Commodities  = KeyButtonB (CommoditiesText  ,'k',ID_COMMODITIES),
               Child, BT_Interrupts   = KeyButtonB (InterruptsText   ,'i',ID_INTERRUPTS),
               Child, BT_Vectors      = KeyButtonB (VectorsText      ,'v',ID_VECTORS),

               Child, BT_ScreenMode   = KeyButtonB (ScreenModeText   ,'z',ID_SCREENMODE),
               Child, BT_Windows      = KeyButtonB (WindowsText      ,'w',ID_WINDOWS),
               Child, BT_Fonts        = KeyButtonB (FontsText        ,'f',ID_FONTS),
               Child, BT_Classes      = KeyButtonB (ClassesText      ,'b',ID_CLASSES),
               Child, BT_InputHandler = KeyButtonB (InputHandlersText,'h',ID_INPUTHANDLER),

               Child, BT_Assigns      = KeyButtonB (AssignsText      ,'g',ID_ASSIGNS),
               Child, BT_Locks        = KeyButtonB (LocksText        ,'o',ID_LOCKS),
               Child, BT_Mount        = KeyButtonB (MountText        ,'n',ID_MOUNT),
               Child, BT_Commands     = KeyButtonB (CommandsText     ,'c',ID_COMMANDS),
               Child, BT_Timer        = KeyButtonB (TimerText        ,'e',ID_TIMER),

               Child, BT_System       = KeyButtonB (SystemText       ,'y',ID_SYSTEM),
               Child, BT_Expansions   = KeyButtonB (ExpansionsText   ,'x',ID_EXPANSIONS),
               Child, BT_Memory       = KeyButtonB (MemoryText       ,'m',ID_MEMORY),
               Child, BT_LowMemory    = KeyButtonB (LowMemoryText    ,'j',ID_LOWMEMORY),
               Child, BT_Residents    = KeyButtonB (ResidentsText    ,'r',ID_RESIDENTS),
            End,
         End,
      End;

      if (WI_Main) {
         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Main);
         SetCloseRequest (WI_Main,(int) MUIV_Application_ReturnID_Quit);
         DoMethod (WI_Main,MUIM_Window_SetCycleChain,
                    BT_Libraries,BT_Devices,BT_Resources,BT_System,
                    BT_Tasks,BT_Ports,BT_Commands,BT_Commodities,
                    BT_Expansions,BT_Memory,BT_Residents,BT_LowMemory,
                    BT_Assigns,BT_Locks,BT_Mount,BT_Timer,
                    BT_InputHandler,BT_Interrupts,BT_Vectors,BT_Allocations,
                    BT_Fonts,BT_Semaphores,BT_Windows,BT_ScreenMode,NULL);

//         DoMethod (AP_Scout,MUIM_Notify,MUIA_Application_DoubleStart,TRUE,AsP_Scout,2,MUIM_Application_ReturnID,ID_DOUBLESTART);
      }
   }
   return (AP_Scout);
}

char mount_title[WINDOWTITLELEN];

void MountWindow (BOOL state) {
   if (state) {
      if (WI_Mount) {
         ShowMounts();
      } else {
         WI_Mount = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (mount_title, "MOUNTED DEVICES"),
         MUIA_HelpNode, MountText,
         MUIA_Window_ID, MakeListID('M','O','D','E'),
         WindowContents, VGroup,
            Child, mountlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8 P=\33r,COL=5 DELTA=8 P=\33c,COL=6 DELTA=8 P=\33c,COL=7",&mountlist_dsphook),
            Child, MyBelowListview (&mounttext, &mountcount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_MountUpdate = KeyButtonA (UpdateText,ID_MOUNTUPDATE),
               Child, BT_MountPrint  = KeyButtonA (PrintText ,ID_MOUNTPRINT),
               Child, BT_MountMore   = KeyButtonA (MoreText  ,ID_MOUNTMORE),
               Child, BT_MountExit   = KeyButtonA (ExitText  ,ID_MOUNTEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Mount);
         DoMethod (WI_Mount,MUIM_Window_SetCycleChain,mountlist,BT_MountUpdate,BT_MountPrint,BT_MountMore,BT_MountExit,NULL);

         SetCloseRequest (WI_Mount,ID_MOUNTEXIT);
         SetListActive (mountlist,ID_MOUNTLV_ACTIVE);
         SetListviewDoubleClick (mountlist,ID_MOUNTMORE);

         ShowMounts();

         SetWindowOpen (WI_Mount,mountlist,ID_MOUNTEXIT);
      }
   } else if ((! state) && (WI_Mount)) {
      SetWindowClose (WI_Mount,TRUE);

      FreeMounts();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Mount);
      MUI_DisposeObject (WI_Mount);
      WI_Mount = NULL;
      mountlist = NULL;
   }
}

char windows_title[WINDOWTITLELEN];

void WindowsWindow (BOOL state) {
   if (state) {
      if (WI_Windows) {
         ShowWindows();
      } else {
         WI_Windows = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (windows_title, "WINDOWS & SCREENS"),
         MUIA_HelpNode, WindowsText,
         MUIA_Window_ID, MakeListID('W','I','N','D'),
         WindowContents, VGroup,
            Child, winlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8 P=\33c,COL=2 DELTA=8 P=\33c,COL=3 DELTA=8,COL=4 DELTA=8,COL=5",&winlist_dsphook),
            Child, wintext = MyTextObject(),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_WinUpdate  = KeyButtonA (UpdateText,ID_WINUPDATE),
               Child, BT_WinPrint   = KeyButtonA (PrintText ,ID_WINPRINT),
               Child, BT_WinClose   = KeyButtonA (CloseText ,ID_WINCLOSE),
               Child, BT_WinToFront = KeyButtonA (ToFrontText ,ID_WINTOFRONT),
               Child, BT_WinMore    = KeyButtonA (MoreText  ,ID_WINMORE),
               Child, BT_WinExit    = KeyButtonA (ExitText  ,ID_WINEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Windows);
         DoMethod (WI_Windows,MUIM_Window_SetCycleChain,winlist,BT_WinUpdate,BT_WinPrint,BT_WinClose,BT_WinToFront,BT_WinMore,BT_WinExit,NULL);

         SetCloseRequest (WI_Windows,ID_WINEXIT);
         SetListActive (winlist,ID_WINLV_ACTIVE);
         SetListviewDoubleClick (winlist,ID_WINMORE);

         SetWindowOpen (WI_Windows,winlist,ID_WINEXIT);

         ShowWindows();
      }
   } else if ((! state) && (WI_Windows)) {
      SetWindowClose (WI_Windows,TRUE);

      FreeWindows();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Windows);
      MUI_DisposeObject (WI_Windows);
      WI_Windows = NULL;
      winlist = NULL;
   }
}

char residents_title[WINDOWTITLELEN];

void ResidentsWindow (BOOL state) {
   if (state) {
      if (WI_Residents) {
         ShowResidents();
      } else {
         WI_Residents = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (residents_title, "RESIDENTS"),
         MUIA_HelpNode, ResidentsText,
         MUIA_Window_ID, MakeListID('R','E','S','I'),
         WindowContents, VGroup,
            Child, resilist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3",&resilist_dsphook),
            Child, MyBelowListview (&resitext, &resicount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_ResiUpdate     = KeyButtonA (UpdateText,ID_RESIUPDATE),
               Child, BT_ResiPrint      = KeyButtonA (PrintText ,ID_RESIPRINT),
               Child, BT_ResiMore       = KeyButtonA (MoreText  ,ID_RESIMORE),
               Child, BT_ResiExit       = KeyButtonA (ExitText  ,ID_RESIEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Residents);
         DoMethod (WI_Residents,MUIM_Window_SetCycleChain,resilist,BT_ResiUpdate,BT_ResiPrint,BT_ResiMore,BT_ResiExit,NULL);

         SetCloseRequest (WI_Residents,ID_RESIEXIT);
         SetListActive (resilist,ID_RESILV_ACTIVE);
         SetListviewDoubleClick (resilist,ID_RESIMORE);

         ShowResidents();

         SetWindowOpen (WI_Residents,resilist,ID_RESIEXIT);
      }
   } else if ((! state) && (WI_Residents)) {
      SetWindowClose (WI_Residents,TRUE);

      FreeResidents();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Residents);
      MUI_DisposeObject (WI_Residents);
      WI_Residents = NULL;
      resilist = NULL;
   }
}

char expansions_title[WINDOWTITLELEN];

void ExpansionsWindow (BOOL state) {
   if (state) {
      if (WI_Expansions) {
         ShowExpansions();
      } else {
         WI_Expansions = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (expansions_title, "EXPANSIONS"),
         MUIA_HelpNode, ExpansionsText,
         MUIA_Window_ID, MakeListID('E','X','P','A'),
         WindowContents, VGroup,
            Child, explist = MyListviewObject ("DELTA=8,DELTA=8,DELTA=8,,",&explist_dsphook),
            Child, exptext = MyTextObject(),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_ExpPrint     = KeyButtonA (PrintText,ID_EXPPRINT),
               Child, BT_ExpMore      = KeyButtonA (MoreText ,ID_EXPMORE),
               Child, BT_ExpExit      = KeyButtonA (ExitText ,ID_EXPEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Expansions);
         DoMethod (WI_Expansions,MUIM_Window_SetCycleChain,explist,BT_ExpPrint,BT_ExpMore,BT_ExpExit,NULL);

         SetCloseRequest (WI_Expansions,ID_EXPEXIT);
         SetListActive (explist,ID_EXPLV_ACTIVE);
         SetListviewDoubleClick (explist,ID_EXPMORE);

         ShowExpansions();

         SetWindowOpen (WI_Expansions,explist,ID_EXPEXIT);
      }
   } else if ((! state) && (WI_Expansions)) {
      SetWindowClose (WI_Expansions,TRUE);

      FreeExpansions();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Expansions);
      MUI_DisposeObject (WI_Expansions);
      WI_Expansions = NULL;
      explist = NULL;
   }
}

char inputhandler_title[WINDOWTITLELEN];

void InputHandlerWindow (BOOL state) {
   if (state) {
      if (WI_InputHandler) {
         ShowInputHandler();
      } else {
         WI_InputHandler = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (inputhandler_title, "INPUTHANDLERS"),
         MUIA_HelpNode, InputHandlersText,
         MUIA_Window_ID, MakeListID('I','N','P','U'),
         WindowContents, VGroup,
            Child, inputlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8,COL=5",&inputlist_dsphook),
            Child, MyBelowListview (&inputtext, &inputcount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_InputUpdate    = KeyButtonA (UpdateText  ,ID_INPUTUPDATE),
               Child, BT_InputPrint     = KeyButtonA (PrintText   ,ID_INPUTPRINT),
               Child, BT_InputRemove    = KeyButtonA (RemoveText  ,ID_INPUTREMOVE),
               Child, BT_InputPriority  = KeyButtonA (PriorityText,ID_INPUTPRIORITY),
               Child, BT_InputExit      = KeyButtonA (ExitText    ,ID_INPUTEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_InputHandler);
         DoMethod (WI_InputHandler,MUIM_Window_SetCycleChain,inputlist,BT_InputUpdate,BT_InputPrint,BT_InputRemove,BT_InputPriority,BT_InputExit,NULL);

         SetCloseRequest (WI_InputHandler,ID_INPUTEXIT);
         SetListActive (inputlist,ID_INPUTLV_ACTIVE);

         ShowInputHandler();

         SetWindowOpen (WI_InputHandler,inputlist,ID_INPUTEXIT);
      }
   } else if ((! state) && (WI_InputHandler)) {
      SetWindowClose (WI_InputHandler,TRUE);

      FreeInputHandler();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_InputHandler);
      MUI_DisposeObject (WI_InputHandler);
      WI_InputHandler = NULL;
      inputlist = NULL;
   }
}

char lowmemory_title[WINDOWTITLELEN];

void LowMemoryWindow (BOOL state) {
   if (state) {
      if (WI_LowMemory) {
         ShowLowMemory();
      } else {
         WI_LowMemory = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (lowmemory_title, "LOWMEMORY"),
         MUIA_HelpNode, LowMemoryText,
         MUIA_Window_ID, MakeListID('L','O','W','M'),
         WindowContents, VGroup,
            Child, lowmemorylist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8,COL=5",&lowmemorylist_dsphook),
            Child, MyBelowListview (&lowmemorytext, &lowmemorycount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_LowMemoryUpdate    = KeyButtonA (UpdateText  ,ID_LOWMEMORYUPDATE),
               Child, BT_LowMemoryPrint     = KeyButtonA (PrintText   ,ID_LOWMEMORYPRINT),
//*               Child, BT_LowMemoryCause     = KeyButtonA (CauseText   ,ID_LOWMEMORYCAUSE),
               Child, BT_LowMemoryRemove    = KeyButtonA (RemoveText  ,ID_LOWMEMORYREMOVE),
               Child, BT_LowMemoryPriority  = KeyButtonA (PriorityText,ID_LOWMEMORYPRIORITY),
               Child, BT_LowMemoryExit      = KeyButtonA (ExitText    ,ID_LOWMEMORYEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_LowMemory);
         DoMethod (WI_LowMemory,MUIM_Window_SetCycleChain,lowmemorylist,BT_LowMemoryUpdate,BT_LowMemoryPrint,BT_LowMemoryRemove,BT_LowMemoryPriority,BT_LowMemoryExit,NULL);

         SetCloseRequest (WI_LowMemory,ID_LOWMEMORYEXIT);
         SetListActive (lowmemorylist,ID_LOWMEMORYLV_ACTIVE);

         ShowLowMemory();

         SetWindowOpen (WI_LowMemory,lowmemorylist,ID_LOWMEMORYEXIT);
      }
   } else if ((! state) && (WI_LowMemory)) {
      SetWindowClose (WI_LowMemory,TRUE);

      FreeLowMemory();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_LowMemory);
      MUI_DisposeObject (WI_LowMemory);
      WI_LowMemory = NULL;
      lowmemorylist = NULL;
   }
}




char timer_title[WINDOWTITLELEN];

void TimerWindow (BOOL state) {
   if (state) {
      if (WI_Timer) {
         ShowTimer();
      } else {
         WI_Timer = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (timer_title, "TIMER REQUESTS"),
         MUIA_HelpNode, TimerText,
         MUIA_Window_ID, MakeListID('T','I','M','R'),
         WindowContents, VGroup,
            Child, timerlist = MyListviewObject ("DELTA=8,DELTA=8,DELTA=8 P=\33r,DELTA=8 P=\33c,",&timerlist_dsphook),
            Child, MyBelowListview (&timertext, &timercount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_TimerUpdate    = KeyButtonA (UpdateText  ,ID_TIMERUPDATE),
               Child, BT_TimerPrint     = KeyButtonA (PrintText   ,ID_TIMERPRINT),
//*               Child, BT_TimerRemove    = KeyButtonA (RemoveText  ,ID_TIMERREMOVE),
               Child, BT_TimerExit      = KeyButtonA (ExitText    ,ID_TIMEREXIT),
            End,
         End, End;

         set(timerlist,MUIA_List_CompareHook,&list_cmpaddresshook);

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Timer);
         DoMethod (WI_Timer,MUIM_Window_SetCycleChain,timerlist,BT_TimerUpdate,BT_TimerPrint,BT_TimerExit,NULL);

         SetCloseRequest (WI_Timer,ID_TIMEREXIT);
         SetListActive (timerlist,ID_TIMERLV_ACTIVE);

         ShowTimer();

         SetWindowOpen (WI_Timer,timerlist,ID_TIMEREXIT);
      }
   } else if ((! state) && (WI_Timer)) {
      SetWindowClose (WI_Timer,TRUE);

      FreeTimer();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Timer);
      MUI_DisposeObject (WI_Timer);
      WI_Timer = NULL;
      timerlist = NULL;
   }
}


char semaphores_title[WINDOWTITLELEN];

void SemaphoresWindow (BOOL state) {
   if (state) {
      if (WI_Semaphores) {
         ShowSemaphores();
      } else {
         WI_Semaphores = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (semaphores_title, "SEMAPHORES"),
         MUIA_HelpNode, SemaphoresText,
         MUIA_Window_ID, MakeListID('S','E','M','A'),
         WindowContents, VGroup,
            Child, semlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8",&semlist_dsphook),
            Child, MyBelowListview (&semtext, &semcount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_SemUpdate   = KeyButtonA (UpdateText ,ID_SEMUPDATE),
               Child, BT_SemPrint    = KeyButtonA (PrintText  ,ID_SEMPRINT),
               Child, BT_SemObtain   = KeyButtonA (ObtainText ,ID_SEMOBTAIN),
               Child, BT_SemRelease  = KeyButtonA (ReleaseText,ID_SEMRELEASE),
               Child, BT_SemRemove   = KeyButtonA (RemoveText ,ID_SEMREMOVE),
               Child, BT_SemExit     = KeyButtonA (ExitText   ,ID_SEMEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Semaphores);
         DoMethod (WI_Semaphores,MUIM_Window_SetCycleChain,semlist,BT_SemUpdate,BT_SemPrint,BT_SemObtain,BT_SemRelease,BT_SemRemove,BT_SemExit,NULL);

         SetCloseRequest (WI_Semaphores,ID_SEMEXIT);
         SetListActive (semlist,ID_SEMLV_ACTIVE);

         ShowSemaphores();

         SetWindowOpen (WI_Semaphores,semlist,ID_SEMEXIT);
      }
   } else if ((! state) && (WI_Semaphores)) {
      SetWindowClose (WI_Semaphores,TRUE);

      FreeSemaphores();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Semaphores);
      MUI_DisposeObject (WI_Semaphores);
      WI_Semaphores = NULL;
      semlist = NULL;
   }
}

char interrupts_title[WINDOWTITLELEN];

void InterruptsWindow (BOOL state) {
   if (state) {
      if (WI_Interrupts) {
         ShowInterrupts();
      } else {
         WI_Interrupts = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (interrupts_title, "INTERRUPTS"),
         MUIA_HelpNode, InterruptsText,
         MUIA_Window_ID, MakeListID('I','N','T','E'),
         WindowContents, VGroup,
            Child, intlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8,COL=4 DELTA=8,COL=5 DELTA=8 P=\33r,COL=6",&intlist_dsphook),
            Child, MyBelowListview (&inttext, &intcount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_IntUpdate   = KeyButtonA (UpdateText,ID_INTUPDATE),
               Child, BT_IntPrint    = KeyButtonA (PrintText ,ID_INTPRINT),
               Child, BT_IntRemove   = KeyButtonA (RemoveText,ID_INTREMOVE),
               Child, BT_IntMore     = KeyButtonA (MoreText  ,ID_INTMORE),
               Child, BT_IntExit     = KeyButtonA (ExitText  ,ID_INTEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Interrupts);
         DoMethod (WI_Interrupts,MUIM_Window_SetCycleChain,intlist,BT_IntUpdate,BT_IntPrint,BT_IntRemove,BT_IntMore,BT_IntExit,NULL);

         SetCloseRequest (WI_Interrupts,ID_INTEXIT);
         SetListActive (intlist,ID_INTLV_ACTIVE);
         SetListviewDoubleClick (intlist,ID_INTMORE);

         ShowInterrupts();

         SetWindowOpen (WI_Interrupts,intlist,ID_INTEXIT);
      }
   } else if ((! state) && (WI_Interrupts)) {
      SetWindowClose (WI_Interrupts,TRUE);

      FreeInterrupts();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Interrupts);
      MUI_DisposeObject (WI_Interrupts);
      WI_Interrupts = NULL;
      intlist = NULL;
   }
}

char fonts_title[WINDOWTITLELEN];

void FontsWindow (BOOL state) {
   if (state) {
      if (WI_Fonts) {
         ShowFonts();
      } else {
         WI_Fonts = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (fonts_title, "FONTS"),
         MUIA_HelpNode, FontsText,
         MUIA_Window_ID, MakeListID('F','O','N','T'),
         WindowContents, VGroup,
            Child, fontlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8 P=\33r,COL=2 DELTA=8,COL=3 DELTA=8,COL=4 DELTA=8 P=\33r,COL=5 DELTA=8 P=\33r,COL=6 DELTA=8 P=\33r,COL=7 DELTA=8,COL=8",&fontlist_dsphook),
            Child, MyBelowListview (&fonttext, &fontcount),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_FontUpdate  = KeyButtonA (UpdateText,ID_FONTUPDATE),
               Child, BT_FontPrint   = KeyButtonA (PrintText ,ID_FONTPRINT),
               Child, BT_FontClose   = KeyButtonA (CloseText,ID_FONTCLOSE),
               Child, BT_FontRemove  = KeyButtonA (RemoveText,ID_FONTREMOVE),
               Child, BT_FontExit    = KeyButtonA (ExitText  ,ID_FONTEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Fonts);
         DoMethod (WI_Fonts,MUIM_Window_SetCycleChain,fontlist,BT_FontUpdate,BT_FontPrint,BT_FontClose,BT_FontRemove,BT_FontExit,NULL);

         SetCloseRequest (WI_Fonts,ID_FONTEXIT);
         SetListActive (fontlist,ID_FONTLV_ACTIVE);

         ShowFonts();

         SetWindowOpen (WI_Fonts,fontlist,ID_FONTEXIT);
      }
   } else if ((! state) && (WI_Fonts)) {
      SetWindowClose (WI_Fonts,TRUE);

      FreeFonts();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Fonts);
      MUI_DisposeObject (WI_Fonts);
      WI_Fonts = NULL;
      fontlist = NULL;
   }
}

static const char *CYA_CpuUsageText[] = {
   "off",
   "full",
   " in % ",
   NULL
};

__asm void cpuinterval_callfunc(register __a1 unsigned char **contents) {
   int      i, j, t;
   long     micros = NULL;
   UBYTE    text[8];

   if ((switchstate) && (*switchstate)) {
      AbortIO ((struct IORequest *) &TimerIORequest);
   }

   strncpy (text, *contents, 6);

   i = 0;
   while ((text[i] != '\0') && (text[i] != '.')) {
      i++;
   }
   if (text[i] == '.') {
      t = 1;
      text[i] = '\0';
      while (isdigit (text[++i])) {
         if (j = (int) (text[i] - '0')) {
            t *= 10;
            micros += (1000000 / t) * j;
         }
      }
   }
   cpumicros = micros;
   cpuseconds = atol ((char const *) &text);
   strcpy (updatetimetext,*contents);

   if ((switchstate) && (*switchstate)) {
      TimerIORequest.tr_time.tv_secs = cpuseconds;
      TimerIORequest.tr_time.tv_micro = cpumicros;
      TimerIORequest.tr_node.io_Command = TR_ADDREQUEST;
      SendIO ((struct IORequest *) &TimerIORequest);
   }
}

struct Hook cpuinterval_callhook = {
 {NULL, NULL},
 (ULONG (* )())cpuinterval_callfunc,
 NULL, NULL
};

/* Beispiel-EditHook aus RKM-Libraries Seite 164 */
/*
__asm ULONG realstring_editfunc(register __a0 struct Hook *hook, register __a2 struct SGWork *sgw, register __a1 ULONG *msg) {
   UBYTE *work_ptr;
   ULONG return_code;

   return_code = ~0L;

   if (*msg == SGH_KEY) {
      if ((sgw->EditOp == EO_REPLACECHAR) || (sgw->EditOp == EO_INSERTCHAR)) {
         if (!IsHexDigit (sgw->Code)) {
            sgw->Actions |= SGA_BEEP;
            sgw->Actions &= ~SGA_USE;
         } else {
            sgw->WorkBuffer[sgw->BufferPos - 1] = ToUpper (sgw->Code);
         }
      }
   } else if (*msg == SGH_CLICK) {
      if (sgw->BufferPos < sgw->NumChars) {
         work_ptr = sgw->WorkBuffer + sgw->BufferPos;
         *work_ptr = '0';
      }
   } else {
      return_code = 0;
   }
   return (return_code);
}
*/

__asm ULONG hexstring_editfunc (register __a0 struct Hook *hook, register __a2 struct SGWork *sgw, register __a1 ULONG *msg) {
   ULONG return_code;
   int   i = 0;
   char  c;

   return_code = ~0L;

   if (*msg == SGH_KEY) {
      long  tmplong;

      if ((sgw->EditOp == EO_REPLACECHAR) || (sgw->EditOp == EO_INSERTCHAR)) {
         if (sgw->WorkBuffer[0] == '$')
            i = 1;
         if (! strncmp ("0x", sgw->WorkBuffer, 2))
            i = 2;
         while (c = sgw->WorkBuffer[i]) {
            if ((! ((c >= '0') && (c <= '9'))) \
              && (! ((c >= 'a') && (c <= 'f'))) \
              && (! ((c >= 'A') && (c <= 'F')))) {
               sgw->Actions |= SGA_BEEP;
               sgw->Actions &= ~SGA_USE;
               break;
            }
            i++;
         }
      } else if ((sgw->EditOp == EO_ENTER) && (! IsHex (sgw->WorkBuffer, &tmplong))) {
         sgw->Actions |= SGA_BEEP;
         sgw->Actions &= ~SGA_END;
      }
   } else {
      return_code = 0;
   }
   return (return_code);
}

struct Hook hexstring_edithook = {
 {NULL, NULL},
 (ULONG (* )())hexstring_editfunc,
 NULL, NULL
};

__asm ULONG realstring_editfunc(register __a0 struct Hook *hook, register __a2 struct SGWork *sgw, register __a1 ULONG *msg) {
   ULONG return_code;
   int   i = 0,punkte = 0,notzeros = 0;

   return_code = ~0L;

   if (*msg == SGH_KEY) {
      if ((sgw->EditOp == EO_REPLACECHAR) || (sgw->EditOp == EO_INSERTCHAR)) {
         while (sgw->WorkBuffer[i]) {
            if (sgw->WorkBuffer[i++] == '.')
               punkte++;
         }
         if ((punkte > 1) || ((!isdigit (sgw->Code)) && (sgw->Code != '.'))) {
            sgw->Actions |= SGA_BEEP;
            sgw->Actions &= ~SGA_USE;
         }
      } else if (sgw->EditOp == EO_ENTER) {
         while (sgw->WorkBuffer[i]) {
            if ((sgw->WorkBuffer[i] >= '1') && (sgw->WorkBuffer[i] <= '9'))
               notzeros++;
            i++;
         }
         if ((sgw->EditOp == EO_ENTER) && (!notzeros)) {
            sgw->Actions |= SGA_BEEP;
            sgw->Actions &= ~SGA_END;
         }
      }
   } else {
      return_code = 0;
   }
   return (return_code);
}

struct Hook realstring_edithook = {
 {NULL, NULL},
 (ULONG (* )())realstring_editfunc,
 NULL, NULL
};

APTR TaskSortList[] = {
   &tasklist_cmpaddresshook,
   &list_cmpnamehook,
   &tasklist_cmpprihook,
   NULL
};

static const char *CYA_TaskSortText[] = {
   "address",
   "name",
   "priority",
   NULL
};

APTR WI_Tasks, tasklist, tasktext, tasktext2, taskcount, CY_TaskSort;
int  tasksortstate = 0;
APTR BT_TaskPrint, BT_TaskFreeze, BT_TaskActivate, cpucount, CY_CpuUsage;
APTR BT_TaskUpdate, BT_TaskRemove, BT_TaskSignal, BT_TaskBreak, BT_TaskPriority, BT_TaskMore, BT_TaskExit;

char tasks_title[WINDOWTITLELEN];

void TasksWindow (BOOL state) {
   if (state) {
      if (WI_Tasks) {
         ShowTasks();
      } else {
         WI_Tasks = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (tasks_title, "TASKS"),
         MUIA_HelpNode, TasksText,
         MUIA_Window_ID, MakeListID('T','A','S','K'),
         WindowContents, VGroup,
            Child, tasklist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8 P=\33c,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8 P=\33c,COL=5 DELTA=8,COL=6 DELTA=8 P=\33r,COL=7",&tasklist_dsphook),
            Child, MyBelowSortedListview (&tasktext, &taskcount, &CY_TaskSort, CYA_TaskSortText, tasksortstate),
            Child, MyVSpace(2),
            Child, VGroup,
               Child, HGroup, MUIA_Group_SameSize, TRUE,
                  Child, BT_TaskPrint    = KeyButtonA (PrintText   ,ID_TASKPRINT),
                  Child, BT_TaskFreeze   = KeyButtonA (FreezeText  ,ID_TASKFREEZE),
                  Child, BT_TaskActivate = KeyButtonA (ActivateText,ID_TASKACTIVATE),
                  Child, HGroup,
                     Child, MyLabel2 (" CPU:"),
//*                     Child, cpucount = MyTextObject3(ESC "c-----"),
                     Child, cpucount = GaugeObject,
                       MUIA_Frame         , MUIV_Frame_Gauge,
                       MUIA_Gauge_Horiz   , TRUE,
                       MUIA_Gauge_Max     , 100,
                       MUIA_Gauge_InfoText, "\0330-----",
                       MUIA_Gauge_Current , 0,
                     End,
                  End,
                  Child, CY_CpuUsage = CycleObject,
                     MUIA_Weight, 0,
                     MUIA_Cycle_Entries, CYA_CpuUsageText,
                     MUIA_Cycle_Active, updatetimestate,
                  End,
                  Child, HGroup,
                     Child, MyLabel2 (" Secs:"),
                     Child, tasktext2 = StringObject,
                        MUIA_String_BufferPos, 1,
                        MUIA_String_MaxLen, 6, StringFrame,
                        MUIA_String_EditHook, &realstring_edithook,
                        MUIA_String_Contents, updatetimetext,
                     End,
                  End,
               End,
               Child, HGroup, MUIA_Group_SameSize, TRUE,
                  Child, BT_TaskUpdate   = KeyButtonA (UpdateText  ,ID_TASKUPDATE),
                  Child, BT_TaskRemove   = KeyButtonA (RemoveText  ,ID_TASKREMOVE),
                  Child, BT_TaskSignal   = KeyButtonA (SignalText  ,ID_TASKSIGNAL),
                  Child, BT_TaskBreak    = KeyButtonA (BreakText   ,ID_TASKBREAK),
                  Child, BT_TaskPriority = KeyButtonA (PriorityText,ID_TASKPRIORITY),
                  Child, BT_TaskMore     = KeyButtonA (MoreText    ,ID_TASKMORE),
                  Child, BT_TaskExit     = KeyButtonA (ExitText    ,ID_TASKEXIT),
               End,
            End,
         End, End;

         if (WI_Tasks) {
            DoMethod (AP_Scout,OM_ADDMEMBER,WI_Tasks);
            DoMethod (WI_Tasks,MUIM_Window_SetCycleChain,tasklist,CY_TaskSort,BT_TaskPrint,BT_TaskFreeze,BT_TaskActivate,CY_CpuUsage,tasktext2,BT_TaskUpdate,BT_TaskRemove,BT_TaskSignal,BT_TaskBreak,BT_TaskPriority,BT_TaskMore,BT_TaskExit,NULL);
            DoMethod (CY_CpuUsage, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_CPUUSAGE);
            DoMethod (CY_TaskSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_TASKSORT);
            DoMethod (tasktext2,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,tasktext2,3,MUIM_CallHook,&cpuinterval_callhook,MUIV_TriggerValue);

            SetCloseRequest (WI_Tasks,ID_TASKEXIT);
            SetListActive (tasklist,ID_TASKLV_ACTIVE);
            SetListviewDoubleClick (tasklist,ID_TASKMORE);

            ShowTasks();

            SetWindowOpen (WI_Tasks,tasklist,ID_TASKEXIT);

            if (updatetimestate)
               CheckCPUUsage();
         }
      }
   } else if ((! state) && (WI_Tasks)) {
      if (patchsem)
         *switchstate = FALSE;

      if (cheattask)
         RemoveCheatTask();

      SetWindowClose (WI_Tasks,TRUE);

      FreeTasks();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Tasks);
      MUI_DisposeObject (WI_Tasks);
      WI_Tasks = NULL;
      tasklist = NULL;
   }
}

APTR CxSortList[] = {
   &cxlist_cmpaddresshook,
   &cxlist_cmpnamehook,
   &cxlist_cmpprihook,
   NULL
};

static const char *CYA_CxSortText[] = {
   "address",
   "name",
   "priority",
   NULL
};

APTR WI_Cx, cxlist, cxtext, cxcount, CY_CxSort;
int  cxsortstate = 0;
APTR BT_CxAppear, BT_CxDisappear, BT_CxEnable, BT_CxDisable, BT_CxKill, BT_CxListChg, BT_CxUnique;
APTR BT_CxUpdate, BT_CxPrint, BT_CxPriority, BT_CxRemove, BT_CxMore, BT_CxExit;

char cx_title[WINDOWTITLELEN];

void CxWindow (BOOL state) {
   if (state) {
      if (WI_Cx) {
         ShowCx();
      } else {
         WI_Cx = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (cx_title, "COMMODITIES"),
         MUIA_HelpNode, CommoditiesText,
         MUIA_Window_ID, MakeListID('C','D','I','T'),
         WindowContents, VGroup,
            Child, cxlist = MyListviewObject ("DELTA=8,DELTA=8 P=\33c,DELTA=8 P=\33c,DELTA=8 P=\33c,DELTA=8,",&cxlist_dsphook),
            Child, MyBelowSortedListview (&cxtext, &cxcount, &CY_CxSort, CYA_CxSortText, cxsortstate),
            Child, MyVSpace(2),
            Child, VGroup,
               Child, HGroup, MUIA_Group_SameSize, TRUE,
                  Child, BT_CxAppear     = KeyButtonA (AppearText   ,ID_CXAPPEAR),
                  Child, BT_CxDisappear  = KeyButtonA (DisappearText,ID_CXDISAPPEAR),
                  Child, BT_CxEnable     = KeyButtonA (EnableText   ,ID_CXENABLE),
                  Child, BT_CxDisable    = KeyButtonA (DisableText  ,ID_CXDISABLE),
                  Child, BT_CxKill       = KeyButtonA (KillText     ,ID_CXKILL),
                  Child, BT_CxListChg    = KeyButtonA (ListChgText  ,ID_CXLISTCHG),
                  Child, BT_CxUnique     = KeyButtonA (UniqueText   ,ID_CXUNIQUE),
               End,
               Child, HGroup, MUIA_Group_SameSize, TRUE,
                  Child, BT_CxUpdate     = KeyButtonA (UpdateText   ,ID_CXUPDATE),
                  Child, BT_CxPrint      = KeyButtonA (PrintText    ,ID_CXPRINT),
                  Child, BT_CxPriority   = KeyButtonA (PriorityText ,ID_CXPRIORITY),
                  Child, BT_CxRemove     = KeyButtonA (RemoveText   ,ID_CXREMOVE),
                  Child, BT_CxMore       = KeyButtonA (MoreText     ,ID_CXMORE),
                  Child, BT_CxExit       = KeyButtonA (ExitText     ,ID_CXEXIT),
               End,
            End,
         End, End;

         if (WI_Cx) {
            DoMethod (AP_Scout,OM_ADDMEMBER,WI_Cx);
            DoMethod (WI_Cx,MUIM_Window_SetCycleChain,cxlist,CY_CxSort,BT_CxAppear,BT_CxDisappear,BT_CxEnable,BT_CxDisable,BT_CxKill,BT_CxListChg,BT_CxUnique,BT_CxUpdate,BT_CxPrint,BT_CxPriority,BT_CxRemove,BT_CxMore,BT_CxExit,NULL);
            DoMethod (CY_CxSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_CXSORT);

            SetCloseRequest (WI_Cx,ID_CXEXIT);
            SetListActive (cxlist,ID_CXLV_ACTIVE);
            SetListviewDoubleClick (cxlist,ID_CXMORE);

            ShowCx();

            SetWindowOpen (WI_Cx,cxlist,ID_CXEXIT);
         }
      }
   } else if ((! state) && (WI_Cx)) {
      SetWindowClose (WI_Cx,TRUE);
      FreeCx();
      DoMethod (AP_Scout,OM_REMMEMBER,WI_Cx);
      MUI_DisposeObject (WI_Cx);
      WI_Cx = NULL;
      cxlist = NULL;
   }
}


APTR ClassSortList[] = {
   &classlist_cmpaddresshook,
   &classlist_cmpnamehook,
   &classlist_cmpsuperhook,
   NULL
};

static const char *CYA_ClassSortText[] = {
   "address",
   "name",
   "superclass",
   NULL
};

APTR WI_Class, classlist, classtext, classcount, CY_ClassSort;
int  classsortstate = 0;
APTR BT_ClassUpdate, BT_ClassPrint, BT_ClassRemove, BT_ClassMore, BT_ClassExit;

char class_title[WINDOWTITLELEN];

void ClassWindow (BOOL state) {
   if (state) {
      if (WI_Class) {
         ShowClass();
      } else {
         WI_Class = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (cx_title, "CLASSES"),
         MUIA_HelpNode, ClassesText,
         MUIA_Window_ID, MakeListID('C','L','A','S'),
         WindowContents, VGroup,
            Child, classlist = MyListviewObject ("DELTA=8,DELTA=8,DELTA=8,DELTA=8,DELTA=8,",&classlist_dsphook),
            Child, MyBelowSortedListview (&classtext, &classcount, &CY_ClassSort, CYA_ClassSortText, classsortstate),
            Child, MyVSpace(2),
            Child, VGroup,
               Child, HGroup, MUIA_Group_SameSize, TRUE,
                  Child, BT_ClassUpdate     = KeyButtonA (UpdateText   ,ID_CLASSUPDATE),
                  Child, BT_ClassPrint      = KeyButtonA (PrintText    ,ID_CLASSPRINT),
                  Child, BT_ClassRemove     = KeyButtonA (RemoveText   ,ID_CLASSREMOVE),
                  Child, BT_ClassMore       = KeyButtonA (MoreText     ,ID_CLASSMORE),
                  Child, BT_ClassExit       = KeyButtonA (ExitText     ,ID_CLASSEXIT),
               End,
            End,
         End, End;

         if (WI_Class) {
            DoMethod (AP_Scout,OM_ADDMEMBER,WI_Class);
            DoMethod (WI_Class,MUIM_Window_SetCycleChain,classlist,CY_ClassSort,BT_ClassUpdate,BT_ClassPrint,BT_ClassRemove,BT_ClassMore,BT_ClassExit,NULL);
            DoMethod (CY_ClassSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_CLASSSORT);

            SetCloseRequest (WI_Class,ID_CLASSEXIT);
            SetListActive (classlist,ID_CLASSLV_ACTIVE);
            SetListviewDoubleClick (classlist,ID_CLASSMORE);

            ShowClass();

            SetWindowOpen (WI_Class,classlist,ID_CLASSEXIT);
         }
      }
   } else if ((! state) && (WI_Class)) {
      SetWindowClose (WI_Class,TRUE);
      FFreeClass();
      DoMethod (AP_Scout,OM_REMMEMBER,WI_Class);
      MUI_DisposeObject (WI_Class);
      WI_Class = NULL;
      classlist = NULL;
   }
}

APTR SModeSortList[] = {
   &smodelist_cmpidhook,
   &smodelist_cmpnamehook,
   &smodelist_cmpreshook,
   NULL
};

static const char *CYA_SModeSortText[] = {
   "ModeID",
   "name",
   "resolution",
   NULL
};

APTR WI_SMode, smodelist, smodetext, smodecount, CY_SModeSort;
int  smodesortstate = 0;
APTR BT_SModeUpdate, BT_SModePrint, BT_SModeMore, BT_SModeExit;

char smode_title[WINDOWTITLELEN];

void SModeWindow (BOOL state) {
   if (state) {
      if (WI_SMode) {
         ShowSMode();
      } else {
         WI_SMode = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (smode_title, "SCREENMODE"),
         MUIA_HelpNode, ScreenModeText,
         MUIA_Window_ID, MakeListID('S','M','D','E'),
         WindowContents, VGroup,
            Child, smodelist = MyListviewObject ("DELTA=8,DELTA=8,DELTA=8,DELTA=8,",&smodelist_dsphook),
            Child, MyBelowSortedListview (&smodetext, &smodecount, &CY_SModeSort, CYA_SModeSortText, smodesortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_SModeUpdate     = KeyButtonA (UpdateText   ,ID_SMODEUPDATE),
               Child, BT_SModePrint      = KeyButtonA (PrintText    ,ID_SMODEPRINT),
               Child, BT_SModeMore       = KeyButtonA (MoreText     ,ID_SMODEMORE),
               Child, BT_SModeExit       = KeyButtonA (ExitText     ,ID_SMODEEXIT),
            End,
         End, End;

         if (WI_SMode) {
            DoMethod (AP_Scout,OM_ADDMEMBER,WI_SMode);
            DoMethod (WI_SMode,MUIM_Window_SetCycleChain,smodelist,CY_SModeSort,BT_SModeUpdate,BT_SModePrint,BT_SModeMore,BT_SModeExit,NULL);
            DoMethod (CY_SModeSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_SMODESORT);

            SetCloseRequest (WI_SMode,ID_SMODEEXIT);
            SetListActive (smodelist,ID_SMODELV_ACTIVE);
            SetListviewDoubleClick (smodelist,ID_SMODEMORE);

            ShowSMode();

            SetWindowOpen (WI_SMode,smodelist,ID_SMODEEXIT);
         }
      }
   } else if ((! state) && (WI_SMode)) {
      SetWindowClose (WI_SMode,TRUE);
      FreeSMode();
      DoMethod (AP_Scout,OM_REMMEMBER,WI_SMode);
      MUI_DisposeObject (WI_SMode);
      WI_SMode = NULL;
      smodelist = NULL;
   }
}

APTR LibSortList[] = {
   &list_cmpnormalhook,
   &list_cmpnamehook,
   &list_cmpaddresshook,
   NULL
};

static const char *CYA_LibSortText[] = {
   "priority",
   "name",
   "address",
   NULL
};

APTR WI_Libraries, liblist, libtext, libcount, CY_LibSort;
int  libsortstate = 0;
APTR BT_LibUpdate, BT_LibPrint, BT_LibPriority, BT_LibClose, BT_LibRemove, BT_LibFunctions, BT_LibMore, BT_LibExit;

char libraries_title[WINDOWTITLELEN];

void LibrariesWindow (BOOL state) {
   if (state) {
      if (WI_Libraries) {
         ShowLibraries();
      } else {
         WI_Libraries = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (libraries_title, "LIBRARIES"),
         MUIA_HelpNode, LibrariesText,
         MUIA_Window_ID, MakeListID('L','I','B','S'),
         WindowContents, VGroup,
            Child, liblist = MyListviewObject (LibDevResFormatText,&liblist_dsphook),
            Child, MyBelowSortedListview (&libtext, &libcount, &CY_LibSort, CYA_LibSortText, libsortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_LibPriority  = KeyButtonA (PriorityText ,ID_LIBPRIORITY),
               Child, BT_LibClose     = KeyButtonA (CloseText    ,ID_LIBCLOSE),
               Child, BT_LibRemove    = KeyButtonA (RemoveText   ,ID_LIBREMOVE),
               Child, BT_LibFunctions = KeyButtonA (FunctionsText,ID_LIBFUNCTIONS),
            End,
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_LibUpdate    = KeyButtonA (UpdateText  ,ID_LIBUPDATE),
               Child, BT_LibPrint     = KeyButtonA (PrintText   ,ID_LIBPRINT),
               Child, BT_LibMore      = KeyButtonA (MoreText    ,ID_LIBMORE),
               Child, BT_LibExit      = KeyButtonA (ExitText    ,ID_LIBEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Libraries);
         DoMethod (WI_Libraries,MUIM_Window_SetCycleChain,liblist,CY_LibSort,BT_LibUpdate,BT_LibPrint,BT_LibPriority,BT_LibClose,BT_LibRemove,BT_LibFunctions,BT_LibMore,BT_LibExit,NULL);
         DoMethod (CY_LibSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_LIBSORT);

         SetCloseRequest (WI_Libraries,ID_LIBEXIT);
         SetListActive (liblist,ID_LIBLV_ACTIVE);
         SetListviewDoubleClick (liblist,ID_LIBMORE);

         ShowLibraries();

         SetWindowOpen (WI_Libraries,liblist,ID_LIBEXIT);
      }
   } else if ((! state) && (WI_Libraries)) {
      SetWindowClose (WI_Libraries,TRUE);

      FreeLibraries();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Libraries);
      MUI_DisposeObject (WI_Libraries);
      WI_Libraries = NULL;
      liblist = NULL;
   }
}

APTR WI_Devices, devlist, devtext, devcount, CY_DevSort;
int  devsortstate = 0;
APTR BT_DevUpdate, BT_DevPrint, BT_DevPriority, BT_DevRemove, BT_DevFunctions, BT_DevMore, BT_DevExit;

char devices_title[WINDOWTITLELEN];

void DevicesWindow (BOOL state) {
   if (state) {
      if (WI_Devices) {
         ShowDevices();
      } else {
         WI_Devices = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (devices_title, "DEVICES"),
         MUIA_HelpNode, DevicesText,
         MUIA_Window_ID, MakeListID('D','E','V','S'),
         WindowContents, VGroup,
            Child, devlist = MyListviewObject (LibDevResFormatText,&liblist_dsphook),
            Child, MyBelowSortedListview (&devtext, &devcount, &CY_DevSort, CYA_LibSortText, devsortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_DevPriority  = KeyButtonA (PriorityText ,ID_DEVPRIORITY),
               Child, BT_DevRemove    = KeyButtonA (RemoveText   ,ID_DEVREMOVE),
               Child, BT_DevFunctions = KeyButtonA (FunctionsText,ID_DEVFUNCTIONS),
            End,
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_DevUpdate    = KeyButtonA (UpdateText   ,ID_DEVUPDATE),
               Child, BT_DevPrint     = KeyButtonA (PrintText    ,ID_DEVPRINT),
               Child, BT_DevMore      = KeyButtonA (MoreText     ,ID_DEVMORE),
               Child, BT_DevExit      = KeyButtonA (ExitText     ,ID_DEVEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Devices);
         DoMethod (WI_Devices,MUIM_Window_SetCycleChain,devlist,CY_DevSort,BT_DevUpdate,BT_DevPrint,BT_DevPriority,BT_DevRemove,BT_DevMore,BT_DevFunctions,BT_DevExit,NULL);
         DoMethod (CY_DevSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_DEVSORT);

         SetCloseRequest (WI_Devices,ID_DEVEXIT);
         SetListActive (devlist,ID_DEVLV_ACTIVE);
         SetListviewDoubleClick (devlist,ID_DEVMORE);

         ShowDevices();

         SetWindowOpen (WI_Devices,devlist,ID_DEVEXIT);
      }
   } else if ((! state) && (WI_Devices)) {
      SetWindowClose (WI_Devices,TRUE);

      FreeDevices();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Devices);
      MUI_DisposeObject (WI_Devices);
      WI_Devices = NULL;
      devlist = NULL;
   }
}

APTR WI_Resources, reslist, restext, rescount, CY_ResSort;
int  ressortstate = 0;
APTR BT_ResUpdate, BT_ResPrint, BT_ResPriority, BT_ResRemove, BT_ResFunctions, BT_ResMore, BT_ResExit;

char resources_title[WINDOWTITLELEN];

void ResourcesWindow (BOOL state) {
   if (state) {
      if (WI_Resources) {
         ShowResources();
      } else {
         WI_Resources = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (resources_title, "RESOURCES"),
         MUIA_HelpNode, ResourcesText,
         MUIA_Window_ID, MakeListID('R','E','S','O'),
         WindowContents, VGroup,
            Child, reslist = MyListviewObject (LibDevResFormatText,&liblist_dsphook),
            Child, MyBelowSortedListview (&restext, &rescount, &CY_ResSort, CYA_LibSortText, ressortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_ResPriority  = KeyButtonA (PriorityText ,ID_RESPRIORITY),
               Child, BT_ResRemove    = KeyButtonA (RemoveText   ,ID_RESREMOVE),
               Child, BT_ResFunctions = KeyButtonA (FunctionsText,ID_RESFUNCTIONS),
            End,
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_ResUpdate    = KeyButtonA (UpdateText   ,ID_RESUPDATE),
               Child, BT_ResPrint     = KeyButtonA (PrintText    ,ID_RESPRINT),
               Child, BT_ResMore      = KeyButtonA (MoreText     ,ID_RESMORE),
               Child, BT_ResExit      = KeyButtonA (ExitText     ,ID_RESEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Resources);
         DoMethod (WI_Resources,MUIM_Window_SetCycleChain,reslist,CY_ResSort,BT_ResUpdate,BT_ResPrint,BT_ResPriority,BT_ResRemove,BT_ResFunctions,BT_ResMore,BT_ResExit,NULL);
         DoMethod (CY_ResSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_RESSORT);

         SetCloseRequest (WI_Resources,ID_RESEXIT);
         SetListActive (reslist,ID_RESLV_ACTIVE);
         SetListviewDoubleClick (reslist,ID_RESMORE);

         ShowResources();

         SetWindowOpen (WI_Resources,reslist,ID_RESEXIT);
      }
   } else if ((! state) && (WI_Resources)) {
      SetWindowClose (WI_Resources,TRUE);

      FreeResources();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Resources);
      MUI_DisposeObject (WI_Resources);
      WI_Resources = NULL;
      reslist = NULL;
   }
}

APTR WI_Locks, locklist, locktext, lockcount, CY_LockSort;
int  locksortstate = 0;
APTR lockpattern,locktext2;
APTR BT_LockUpdate, BT_LockPrint, BT_LockRemove, BT_LockExit;

APTR LockSortList[] = {
   &list_cmpnormalhook,
   &locklist_cmppathhook,
   &list_cmpaddresshook,
   NULL
};

static const char *CYA_LockSortText[] = {
   "normal",
   "path",
   "address",
   NULL
};

char locks_title[WINDOWTITLELEN];

void LocksWindow (BOOL state) {
   if (state) {
      if (WI_Locks) {
         ShowLocks();
      } else {
         WI_Locks = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (locks_title, "LOCKS"),
         MUIA_HelpNode, LocksText,
         MUIA_Window_ID, MakeListID('L','O','C','K'),
         WindowContents, VGroup,
            Child, locklist = ListviewObject,
               MUIA_Listview_MultiSelect, TRUE,
               MUIA_Listview_List, ListObject,
               MUIA_List_Format, "COL=0 DELTA=8,COL=1 DELTA=8 P=\33c,COL=2",
               MUIA_List_Title, TRUE,
               MUIA_List_DisplayHook, &locklist_dsphook,
               InputListFrame,
            End, End,
            Child, HGroup,
               Child, locktext = MyTextObject5(SPACE40),
               Child, HGroup, MUIA_HorizWeight, 0,
                  Child, MyLabel ("sorted by:"),
                  Child, CY_LockSort = CycleObject,
                     MUIA_Cycle_Entries, CYA_LockSortText,
                     MUIA_Cycle_Active, locksortstate,
                     MUIA_HorizWeight, 0,
                  End,
               End,
            End,
            Child, locktext2 = MyTextObject(),
            Child, HGroup,
               Child, KeyLabel("Pattern:", 'p'),
               Child, lockpattern = StringObject,
                  MUIA_String_Contents, "#?", MUIA_ControlChar, 'p',
                  MUIA_String_MaxLen, TEXTLENGTH, StringFrame,
               End,
            End,
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_LockUpdate   = KeyButtonA (UpdateText,ID_LOCKUPDATE),
               Child, BT_LockPrint    = KeyButtonA (PrintText ,ID_LOCKPRINT),
               Child, BT_LockRemove   = KeyButtonA (RemoveText,ID_LOCKREMOVE),
               Child, BT_LockExit     = KeyButtonA (ExitText  ,ID_LOCKEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Locks);
         DoMethod (WI_Locks,MUIM_Window_SetCycleChain,locklist,CY_LockSort,lockpattern,BT_LockUpdate,BT_LockPrint,BT_LockRemove,BT_LockExit,NULL);
         DoMethod (CY_LockSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_LOCKSORT);
         DoMethod (lockpattern,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,AP_Scout,2,MUIM_Application_ReturnID,ID_LOCKUPDATE);

         SetCloseRequest (WI_Locks,ID_LOCKEXIT);
         SetListActive (locklist,ID_LOCKLV_ACTIVE);

         SetWindowOpen (WI_Locks,lockpattern,ID_LOCKEXIT);
      }
   } else if ((! state) && (WI_Locks)) {
      SetWindowClose (WI_Locks,TRUE);

      FreeLocks();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Locks);
      MUI_DisposeObject (WI_Locks);
      WI_Locks = NULL;
      locklist = NULL;
   }
}

APTR WI_Ports, portlist, porttext, portcount, CY_PortSort;
int  portsortstate = 0;
APTR BT_PortUpdate, BT_PortPrint, BT_PortRemove, BT_PortPriority, BT_PortMore, BT_PortExit;

APTR PortSortList[] = {
   &tasklist_cmpprihook,
   &list_cmpnamehook,
   &tasklist_cmpaddresshook,
   NULL
};

static const char *CYA_PortSortText[] = {
   "priority",
   "name",
   "address",
   NULL
};

char ports_title[WINDOWTITLELEN];

void PortsWindow (BOOL state) {
   if (state) {
      if (WI_Ports) {
         ShowPorts();
      } else {
         WI_Ports = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (ports_title, "PORTS"),
         MUIA_HelpNode, PortsText,
         MUIA_Window_ID, MakeListID('P','O','R','T'),
         WindowContents, VGroup,
            Child, portlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33r,COL=3 DELTA=8 P=\33c,COL=4",&portlist_dsphook),
            Child, MyBelowSortedListview (&porttext, &portcount, &CY_PortSort, CYA_PortSortText, portsortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_PortUpdate   = KeyButtonA (UpdateText  ,ID_PORTUPDATE),
               Child, BT_PortPrint    = KeyButtonA (PrintText   ,ID_PORTPRINT),
               Child, BT_PortRemove   = KeyButtonA (RemoveText  ,ID_PORTREMOVE),
               Child, BT_PortPriority = KeyButtonA (PriorityText,ID_PORTPRIORITY),
               Child, BT_PortMore     = KeyButtonA (MoreText    ,ID_PORTMORE),
               Child, BT_PortExit     = KeyButtonA (ExitText    ,ID_PORTEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Ports);
         DoMethod (WI_Ports,MUIM_Window_SetCycleChain,portlist,CY_PortSort,BT_PortUpdate,BT_PortPrint,BT_PortRemove,BT_PortPriority,BT_PortMore,BT_PortExit,NULL);
         DoMethod (CY_PortSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_PORTSORT);

         SetCloseRequest (WI_Ports,ID_PORTEXIT);
         SetListActive (portlist,ID_PORTLV_ACTIVE);
         SetListviewDoubleClick (portlist,ID_PORTMORE);

         ShowPorts();

         SetWindowOpen (WI_Ports,portlist,ID_PORTEXIT);
      }
   } else if ((! state) && (WI_Ports)) {
      SetWindowClose (WI_Ports,TRUE);

      FreePorts();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Ports);
      MUI_DisposeObject (WI_Ports);
      WI_Ports = NULL;
      portlist = NULL;
   }
}

char memory_title[WINDOWTITLELEN];

void MemoryWindow (BOOL state) {
   if (state) {
      if (WI_Memory) {
         ShowMemory();
      } else {
         WI_Memory = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (memory_title, "MEMORY"),
         MUIA_HelpNode, MemoryText,
         MUIA_Window_ID, MakeListID('M','E','M','O'),
         WindowContents, VGroup,
            Child, memlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8,COL=3 DELTA=8 P=\33r,COL=4 DELTA=8,COL=5 DELTA=8,COL=6",&memlist_dsphook),
            Child, memtext = MyTextObject(),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_MemPrint    = KeyButtonA (PrintText   ,ID_MEMPRINT),
               Child, BT_MemPriority = KeyButtonA (PriorityText,ID_MEMPRIORITY),
               Child, BT_MemMore     = KeyButtonA (MoreText    ,ID_MEMMORE),
               Child, BT_MemExit     = KeyButtonA (ExitText    ,ID_MEMEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Memory);
         DoMethod (WI_Memory,MUIM_Window_SetCycleChain,memlist,BT_MemPrint,BT_MemPriority,BT_MemMore,BT_MemExit,NULL);

         SetCloseRequest (WI_Memory,ID_MEMEXIT);
         SetListActive (memlist,ID_MEMLV_ACTIVE);
         SetListviewDoubleClick (memlist,ID_MEMMORE);

         ShowMemory();

         SetWindowOpen (WI_Memory,memlist,ID_MEMEXIT);
      }
   } else if ((! state) && (WI_Memory)) {
      SetWindowClose (WI_Memory,TRUE);

      FreeMemory();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Memory);
      MUI_DisposeObject (WI_Memory);
      WI_Memory = NULL;
      memlist = NULL;
   }
}

APTR WI_Assigns, asslist, asstext, asscount, CY_AssSort;
int  asssortstate = 0;
APTR BT_AssUpdate, BT_AssPrint, BT_AssRemove, BT_AssExit;

APTR AssSortList[] = {
   &list_cmpnormalhook,
   &list_cmpnamehook,
   &list_cmpaddresshook,
   NULL
};

static const char *CYA_AssSortText[] = {
   "normal",
   "name",
   "address",
   NULL
};

char assigns_title[WINDOWTITLELEN];

void AssignsWindow (BOOL state) {
   if (state) {
      if (WI_Assigns) {
         ShowAssigns();
      } else {
         WI_Assigns = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (assigns_title, "ASSIGNS"),
         MUIA_HelpNode, AssignsText,
         MUIA_Window_ID, MakeListID('A','S','S','I'),
         WindowContents, VGroup,
            Child, asslist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2",&asslist_dsphook),
            Child, MyBelowSortedListview (&asstext, &asscount, &CY_AssSort, CYA_AssSortText, asssortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_AssUpdate  = KeyButtonA (UpdateText,ID_ASSUPDATE),
               Child, BT_AssPrint   = KeyButtonA (PrintText ,ID_ASSPRINT),
               Child, BT_AssRemove  = KeyButtonA (RemoveText,ID_ASSREMOVE),
               Child, BT_AssExit    = KeyButtonA (ExitText  ,ID_ASSEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Assigns);
         DoMethod (WI_Assigns,MUIM_Window_SetCycleChain,asslist,CY_AssSort,BT_AssUpdate,BT_AssPrint,BT_AssRemove,BT_AssExit,NULL);
         DoMethod (CY_AssSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_ASSSORT);

         SetCloseRequest (WI_Assigns,ID_ASSEXIT);
         SetListActive (asslist,ID_ASSLV_ACTIVE);

         ShowAssigns();

         SetWindowOpen (WI_Assigns,asslist,ID_ASSEXIT);
      }
   } else if ((! state) && (WI_Assigns)) {
      SetWindowClose (WI_Assigns,TRUE);

      FreeAssigns();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Assigns);
      MUI_DisposeObject (WI_Assigns);
      WI_Assigns = NULL;
      asslist = NULL;
   }
}

char vectors_title[WINDOWTITLELEN];

void VectorsWindow (BOOL state) {
   if (state) {
      if (WI_Vectors) {
         GetVectors();
      } else {
         WI_Vectors = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (vectors_title, "VECTORS"),
         MUIA_HelpNode, VectorsText,
         MUIA_Window_ID, MakeListID('V','E','C','T'),
         WindowContents, VGroup,

            Child, RegisterGroup(VectorPages),

               Child, HGroup,
                  GroupFrameT("Reset Vectors"),
                  Child, HGroup,
                     Child, MyLabel2 (ESC "rColdCapture:\nCoolCapture:\nWarmCapture:\nKickMemPtr:\nKickTagPtr:\nKickCheckSum:"),
                     Child, vectext1 = MyTextObject2(),
                  End,
               End,

               Child, HGroup,
                  GroupFrameT("Auto Vector Interrupts"),
                  Child, HGroup,
                     Child, MyLabel2 (ESC "rLevel1 ($0064):\nLevel2 ($0068):\nLevel3 ($006c):\nLevel4 ($0070):\nLevel5 ($0074):\nLevel6 ($0078):\nLevel7 ($007c):"),
                     Child, vectext2 = MyTextObject2(),
                  End,
               End,

               Child, HGroup,
                  GroupFrameT("Interrupt Vectors"),
                  Child, HGroup,
                     Child, MyLabel (ESC "rTBE\nDSKBLK\nSOFTINT\nPORTS\nCOPPER\nVERTB\nBLITTER\nAUDIO0"),
                     Child, MyLabel (ESC "r 0:\n1:\n2:\n3:\n4:\n5:\n6:\n7:"),
                     Child, vectext3 = MyTextObject2(),
                  End,
                  Child, HGroup,
                     Child, MyLabel (ESC "rAUDIO1\nAUDIO2\nAUDIO3\nRBF\nDSKSYNC\nEXTER\nINTEN\nNMI"),
                     Child, MyLabel (ESC "r8:\n9:\n10:\n11:\n12:\n13:\n14:\n15:"),
                     Child, vectext4 = MyTextObject2(),
                  End,
               End,
            End,
#ifndef WINDOW_PROBLEMS
            Child, MyVSpace(4),
#endif
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_VecUpdate = KeyButtonA (UpdateText,ID_VECUPDATE),
               Child, BT_VecPrint  = KeyButtonA (PrintText ,ID_VECPRINT),
               Child, BT_VecExit   = KeyButtonA (ExitText  ,ID_VECEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Vectors);
         DoMethod (WI_Vectors,MUIM_Window_SetCycleChain,BT_VecUpdate,BT_VecPrint,BT_VecExit,NULL);
         SetCloseRequest (WI_Vectors,ID_VECEXIT);

         GetVectors();

         SetWindowOpen (WI_Vectors,NULL,ID_VECEXIT);
      }
   } else if ((! state) && (WI_Vectors)) {
      SetWindowClose (WI_Vectors,TRUE);

//      FreeVectors();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Vectors);
      MUI_DisposeObject (WI_Vectors);
      WI_Vectors = NULL;
   }
}


char allocations_title[WINDOWTITLELEN];

void AllocationsWindow (BOOL state) {
   if (state) {
      if (WI_Allocations) {
         GetAllocations();
      } else {
         WI_Allocations = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (allocations_title, "ALLOCATIONS"),
         MUIA_HelpNode, AllocationsText,
         MUIA_Window_ID, MakeListID('A','L','L','C'),
         WindowContents, VGroup,

            Child, RegisterGroup(AllocationsPages),

               Child, HGroup,
                  Child, HGroup,
                     GroupFrameT("CIA A"),
                     Child, HGroup,
                        Child, MyLabel2 (ESC "rTimer A:\nTimer B:\nAlarm:\nSerial:\nFlag:"),
                        Child, alctext1 = MyTextObject(),
                     End,
                  End,

                  Child, HGroup,
                     GroupFrameT("CIA B"),
                     Child, HGroup,
                        Child, MyLabel2 (ESC "rTimer A:\nTimer B:\nAlarm:\nSerial:\nFlag:"),
                        Child, alctext2 = MyTextObject(),
                     End,
                  End,
               End,

               Child, HGroup,
                  GroupFrameT("Ports"),
                  Child, HGroup,
                     Child, MyLabel2 (ESC "rSerial Port:\nSerial Control:\nParallel Port:\nParallel Control:"),
                     Child, alctext3 = MyTextObject(),
                  End,
               End,
            End,

#ifndef WINDOW_PROBLEMS
            Child, MyVSpace(4),
#endif
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_AlcUpdate = KeyButtonA (UpdateText,ID_ALCUPDATE),
               Child, BT_AlcPrint  = KeyButtonA (PrintText ,ID_ALCPRINT),
               Child, BT_AlcExit   = KeyButtonA (ExitText  ,ID_ALCEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Allocations);
         DoMethod (WI_Allocations,MUIM_Window_SetCycleChain,BT_AlcUpdate,BT_AlcPrint,BT_AlcExit,NULL);
         SetCloseRequest (WI_Allocations,ID_ALCEXIT);

         GetAllocations();

         SetWindowOpen (WI_Allocations,NULL,ID_ALCEXIT);
      }
   } else if ((! state) && (WI_Allocations)) {
      SetWindowClose (WI_Allocations,TRUE);

//      FreeAllocations();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Allocations);
      MUI_DisposeObject (WI_Allocations);
      WI_Allocations = NULL;
   }
}


APTR WI_Commands, comlist, comtext, comcount, CY_ComSort;
int  comsortstate = 0;
APTR BT_ComUpdate, BT_ComPrint, BT_ComRemove, BT_ComExit;

APTR ComSortList[] = {
   &list_cmpnormalhook,
   &list_cmpnamehook,
   &list_cmpaddresshook,
   NULL
};

static const char *CYA_ComSortText[] = {
   "normal",
   "name",
   "address",
   NULL
};

char commands_title[WINDOWTITLELEN];

void CommandsWindow (BOOL state) {
   if (state) {
      if (WI_Commands) {
         ShowCommands();
      } else {
         WI_Commands = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (commands_title, "RESIDENT COMMANDS"),
         MUIA_HelpNode, CommandsText,
         MUIA_Window_ID, MakeListID('R','C','O','M'),
         WindowContents, VGroup,
            Child, comlist = MyListviewObject ("COL=0 DELTA=8,COL=1 DELTA=8,COL=2 DELTA=8 P=\33c,COL=3 DELTA=8,COL=4 DELTA=8,COL=5 P=\33r",&comlist_dsphook),
            Child, MyBelowSortedListview (&comtext, &comcount, &CY_ComSort, CYA_ComSortText, comsortstate),
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_ComUpdate = KeyButtonA (UpdateText,ID_COMUPDATE),
               Child, BT_ComPrint  = KeyButtonA (PrintText ,ID_COMPRINT),
               Child, BT_ComRemove = KeyButtonA (RemoveText,ID_COMREMOVE),
               Child, BT_ComExit   = KeyButtonA (ExitText  ,ID_COMEXIT),
            End,
         End, End;

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_Commands);
         DoMethod (WI_Commands,MUIM_Window_SetCycleChain,comlist,CY_ComSort,BT_ComUpdate,BT_ComPrint,BT_ComRemove,BT_ComExit,NULL);
         DoMethod (CY_ComSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_COMSORT);

         SetCloseRequest (WI_Commands,ID_COMEXIT);
         SetListActive (comlist,ID_COMLV_ACTIVE);

         ShowCommands();

         SetWindowOpen (WI_Commands,comlist,ID_COMEXIT);
      }
   } else if ((! state) && (WI_Commands)) {
      SetWindowClose (WI_Commands,TRUE);

      FreeCommands();

      DoMethod (AP_Scout,OM_REMMEMBER,WI_Commands);
      MUI_DisposeObject (WI_Commands);
      WI_Commands = NULL;
      comlist = NULL;
   }
}


APTR WI_System, syslist, systext;

char system_title[WINDOWTITLELEN];

void SystemWindow (BOOL state) {
   if (state) {
      if (WI_System) {
         ShowSystem();
      } else {
         WI_System = WindowObject,
         MUIA_Window_Title, MyGetWindowTitle (system_title, "SYSTEM"),
         MUIA_HelpNode, SystemText,
         MUIA_Window_ID, MakeListID('S','Y','S','T'),
         WindowContents, VGroup,
            Child, syslist = ListviewObject,
               MUIA_Listview_Input, FALSE,
               MUIA_Listview_List, ListObject,
                  MUIA_Font, MUIV_Font_Fixed,
                  ReadListFrame,
                  MUIA_List_Format, "DELTA=8 BAR P=\33r,",
                  MUIA_List_DisplayHook, &syslist_dsphook,
               End,
            End,
            Child, MyVSpace(2),
            Child, HGroup, MUIA_Group_SameSize, TRUE,
               Child, BT_SysUpdate = KeyButtonA (UpdateText,ID_SYSUPDATE),
               Child, BT_SysPrint  = KeyButtonA (PrintText ,ID_SYSPRINT),
               Child, BT_SysExit   = KeyButtonA (ExitText  ,ID_SYSEXIT),
            End,
         End, End;


         DoMethod (AP_Scout,OM_ADDMEMBER,WI_System);
         DoMethod (WI_System,MUIM_Window_SetCycleChain,syslist,BT_SysPrint,BT_SysExit,NULL);
         SetCloseRequest (WI_System,ID_SYSEXIT);

         ShowSystem();

         SetWindowOpen (WI_System,NULL,ID_SYSEXIT);
      }
   } else if ((! state) && (WI_System)) {
      SetWindowClose (WI_System,TRUE);
      FreeSystem();
      DoMethod (AP_Scout,OM_REMMEMBER,WI_System);
      MUI_DisposeObject (WI_System);
      WI_System = NULL;
   }
}


void AboutWindow (BOOL state) {
   if ((state) && (! WI_About)) {
      WI_About = WindowObject,
      MUIA_Window_Title, PROGNAME " " PROGVERSION "." PROGREVISION,
      WindowContents, VGroup,
         Child, AboutText= MyTextObject2(),
         Child, MyVSpace(4),
         Child, HGroup, MUIA_Group_SameSize, TRUE,
            Child, MyHSpace(0),
            Child, BT_AboutContinue = KeyButtonA (ContinueText,ID_ABOUTCONTINUE),
            Child, MyHSpace(0),
         End,
      End, End;

      if (WI_About) {
         MySetContents (AboutText,"%s%s\n",AboutText1,portname);

         DoMethod (AP_Scout,OM_ADDMEMBER,WI_About);
         SetCloseRequest (WI_About,ID_ABOUTCONTINUE);

         SetWindowOpen (WI_About,BT_AboutContinue,NULL);
      }
   } else if ((! state) && (WI_About)) {
      SetWindowClose (WI_About,FALSE);

      DoMethod (AP_Scout,OM_REMMEMBER,WI_About);
      MUI_DisposeObject (WI_About);
      WI_About = NULL;
   }
}